name: testsPCE run_id: commands[0] env HOME: /home/jenkins env LANG: C.UTF-8 env PATH: /w/workspace/transportpce-tox-verify-transportpce-master/.tox/testsPCE/bin:/opt/pyenv/bin:/tmp/venv-jtcS/bin:/opt/pyenv/shims:/home/jenkins/.local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin:/opt/puppetlabs/bin env PYTHONHASHSEED: 580339589 env PIP_DISABLE_PIP_VERSION_CHECK: 1 env PYTHONIOENCODING: utf-8 env PIP_EXTRA_INDEX_URL: https://gitlab.com/api/v4/projects/33090323/packages/pypi/simple env TOX_ENV_NAME: testsPCE env TOX_WORK_DIR: /w/workspace/transportpce-tox-verify-transportpce-master/.tox env TOX_ENV_DIR: /w/workspace/transportpce-tox-verify-transportpce-master/.tox/testsPCE env VIRTUAL_ENV: /w/workspace/transportpce-tox-verify-transportpce-master/.tox/testsPCE metadata pid: 31070 cwd: /w/workspace/transportpce-tox-verify-transportpce-master/tests allow: /w/workspace/transportpce-tox-verify-transportpce-master/.tox/testsPCE/bin/*:launch_tests.sh cmd: ./launch_tests.sh pce exit_code: 1 pytest -q transportpce_tests/pce/test01_pce.py FFFFFFFFFFF...FFFF.F [100%] =================================== FAILURES =================================== ________________ TransportPCEtesting.test_01_load_port_mapping _________________ self = def test_01_load_port_mapping(self): response = test_utils.post_portmapping(self.port_mapping_data) > self.assertIn(response['status_code'], (requests.codes.created, requests.codes.no_content)) E AssertionError: 401 not found in (201, 204) transportpce_tests/pce/test01_pce.py:112: AssertionError ---------------------------- Captured stdout setup ----------------------------- sample files content loaded starting OpenDaylight... starting KARAF TransportPCE build... Searching for patterns in karaf.log... Pattern found! OpenDaylight started ! _____________ TransportPCEtesting.test_02_load_simple_topology_bi ______________ self = def test_02_load_simple_topology_bi(self): response = test_utils.put_ietf_network('openroadm-topology', self.simple_topo_bi_dir_data) > self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content)) E AssertionError: 401 not found in (200, 204) transportpce_tests/pce/test01_pce.py:118: AssertionError ____________________ TransportPCEtesting.test_03_get_nodeId ____________________ self = def test_03_get_nodeId(self): response = test_utils.get_ietf_network_node_request('openroadm-topology', 'ROADMA01-SRG1', 'config') > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 401 != 200 transportpce_tests/pce/test01_pce.py:124: AssertionError ____________________ TransportPCEtesting.test_04_get_linkId ____________________ self = def test_04_get_linkId(self): > response = test_utils.get_ietf_network_link_request( 'openroadm-topology', 'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX', 'config') transportpce_tests/pce/test01_pce.py:130: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ network = 'openroadm-topology' link = 'XPDRA01-XPDR1-XPDR1-NETWORK1toROADMA01-SRG1-SRG1-PP1-TXRX' content = 'config' def get_ietf_network_link_request(network: str, link: str, content: str): url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}', 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'} if RESTCONF_VERSION in ('rfc8040'): format_args = ('{}', network, link, content) elif content == 'config': format_args = ('{}', content, network, link) else: format_args = ('{}', 'operational', network, link) response = get_request(url[RESTCONF_VERSION].format(*format_args)) res = response.json() return_key = {'rfc8040': 'ietf-network-topology:link', 'draft-bierman02': 'ietf-network-topology:link'} > link = res[return_key[RESTCONF_VERSION]][0] E KeyError: 'ietf-network-topology:link' transportpce_tests/common/test_utils.py:557: KeyError _____________ TransportPCEtesting.test_05_path_computation_xpdr_bi _____________ self = def test_05_path_computation_xpdr_bi(self): > response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) transportpce_tests/pce/test01_pce.py:138: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ api_module = 'transportpce-pce', rpc = 'path-computation-request' payload = {'pce-routing-metric': 'hop-count', 'resource-reserve': 'true', 'service-a-end': {'clli': 'NodeA', 'node-id': 'XPDRA01', 'service-format': 'Ethernet', 'service-rate': '100'}, 'service-handler-header': {'request-id': 'request1'}, ...} def transportpce_api_rpc_request(api_module: str, rpc: str, payload: dict): # pylint: disable=consider-using-f-string url = "{}/operations/{}:{}".format('{}', api_module, rpc) if payload is None: data = None elif RESTCONF_VERSION == 'draft-bierman02': data = prepend_dict_keys({'input': payload}, api_module + ':') else: data = {'input': payload} response = post_request(url, data) if response.status_code == requests.codes.no_content: return_output = None else: res = response.json() return_key = {'rfc8040': api_module + ':output', 'draft-bierman02': 'output'} if response.status_code == requests.codes.internal_server_error: return_output = res else: > return_output = res[return_key[RESTCONF_VERSION]] E KeyError: 'transportpce-pce:output' transportpce_tests/common/test_utils.py:716: KeyError _____________ TransportPCEtesting.test_06_path_computation_rdm_bi ______________ self = def test_06_path_computation_rdm_bi(self): self.path_computation_input_data["service-a-end"]["node-id"] = "ROADMA01" self.path_computation_input_data["service-z-end"]["node-id"] = "ROADMC01" > response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) transportpce_tests/pce/test01_pce.py:150: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ api_module = 'transportpce-pce', rpc = 'path-computation-request' payload = {'pce-routing-metric': 'hop-count', 'resource-reserve': 'true', 'service-a-end': {'clli': 'NodeA', 'node-id': 'ROADMA01', 'service-format': 'Ethernet', 'service-rate': '100'}, 'service-handler-header': {'request-id': 'request1'}, ...} def transportpce_api_rpc_request(api_module: str, rpc: str, payload: dict): # pylint: disable=consider-using-f-string url = "{}/operations/{}:{}".format('{}', api_module, rpc) if payload is None: data = None elif RESTCONF_VERSION == 'draft-bierman02': data = prepend_dict_keys({'input': payload}, api_module + ':') else: data = {'input': payload} response = post_request(url, data) if response.status_code == requests.codes.no_content: return_output = None else: res = response.json() return_key = {'rfc8040': api_module + ':output', 'draft-bierman02': 'output'} if response.status_code == requests.codes.internal_server_error: return_output = res else: > return_output = res[return_key[RESTCONF_VERSION]] E KeyError: 'transportpce-pce:output' transportpce_tests/common/test_utils.py:716: KeyError _____________ TransportPCEtesting.test_07_load_simple_topology_uni _____________ self = def test_07_load_simple_topology_uni(self): response = test_utils.put_ietf_network('openroadm-topology', self.simple_topo_uni_dir_data) > self.assertIn(response['status_code'], (requests.codes.ok, requests.codes.no_content)) E AssertionError: 401 not found in (200, 204) transportpce_tests/pce/test01_pce.py:161: AssertionError ____________________ TransportPCEtesting.test_08_get_nodeId ____________________ self = def test_08_get_nodeId(self): response = test_utils.get_ietf_network_node_request('openroadm-topology', 'XPONDER-1-2', 'config') > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 401 != 200 transportpce_tests/pce/test01_pce.py:167: AssertionError ____________________ TransportPCEtesting.test_09_get_linkId ____________________ self = def test_09_get_linkId(self): > response = test_utils.get_ietf_network_link_request( 'openroadm-topology', 'XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX', 'config') transportpce_tests/pce/test01_pce.py:173: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ network = 'openroadm-topology' link = 'XPONDER-1-2XPDR-NW1-TX-toOpenROADM-1-2-SRG1-SRG1-PP1-RX' content = 'config' def get_ietf_network_link_request(network: str, link: str, content: str): url = {'rfc8040': '{}/data/ietf-network:networks/network={}/ietf-network-topology:link={}?content={}', 'draft-bierman02': '{}/{}/ietf-network:networks/network/{}/ietf-network-topology:link/{}'} if RESTCONF_VERSION in ('rfc8040'): format_args = ('{}', network, link, content) elif content == 'config': format_args = ('{}', content, network, link) else: format_args = ('{}', 'operational', network, link) response = get_request(url[RESTCONF_VERSION].format(*format_args)) res = response.json() return_key = {'rfc8040': 'ietf-network-topology:link', 'draft-bierman02': 'ietf-network-topology:link'} > link = res[return_key[RESTCONF_VERSION]][0] E KeyError: 'ietf-network-topology:link' transportpce_tests/common/test_utils.py:557: KeyError ____________ TransportPCEtesting.test_10_path_computation_xpdr_uni _____________ self = def test_10_path_computation_xpdr_uni(self): self.path_computation_input_data["service-a-end"]["node-id"] = "XPONDER-1-2" self.path_computation_input_data["service-a-end"]["clli"] = "ORANGE1" self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-3-2" self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE3" > response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) transportpce_tests/pce/test01_pce.py:185: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ api_module = 'transportpce-pce', rpc = 'path-computation-request' payload = {'pce-routing-metric': 'hop-count', 'resource-reserve': 'true', 'service-a-end': {'clli': 'ORANGE1', 'node-id': 'XPONDER-1-2', 'service-format': 'Ethernet', 'service-rate': '100'}, 'service-handler-header': {'request-id': 'request1'}, ...} def transportpce_api_rpc_request(api_module: str, rpc: str, payload: dict): # pylint: disable=consider-using-f-string url = "{}/operations/{}:{}".format('{}', api_module, rpc) if payload is None: data = None elif RESTCONF_VERSION == 'draft-bierman02': data = prepend_dict_keys({'input': payload}, api_module + ':') else: data = {'input': payload} response = post_request(url, data) if response.status_code == requests.codes.no_content: return_output = None else: res = response.json() return_key = {'rfc8040': api_module + ':output', 'draft-bierman02': 'output'} if response.status_code == requests.codes.internal_server_error: return_output = res else: > return_output = res[return_key[RESTCONF_VERSION]] E KeyError: 'transportpce-pce:output' transportpce_tests/common/test_utils.py:716: KeyError _____________ TransportPCEtesting.test_11_path_computation_rdm_uni _____________ self = conn = method = 'POST' url = '/rests/operations/transportpce-pce:path-computation-request' body = '{"input": {"service-name": "service-1", "resource-reserve": "true", "service-handler-header": {"request-id": "request...100", "clli": "ncli22", "service-format": "Ethernet", "node-id": "OpenROADM-2-2"}, "pce-routing-metric": "hop-count"}}' headers = {'User-Agent': 'python-requests/2.32.3', 'Accept-Encoding': 'gzip, deflate', 'Accept': 'application/json', 'Connection': 'keep-alive', 'Content-Type': 'application/json', 'Content-Length': '392', 'Authorization': 'Basic YWRtaW46YWRtaW4='} retries = Retry(total=0, connect=None, read=False, redirect=None, status=None) timeout = Timeout(connect=10, read=10, total=None), chunked = False response_conn = preload_content = False, decode_content = False, enforce_content_length = True def _make_request( self, conn: BaseHTTPConnection, method: str, url: str, body: _TYPE_BODY | None = None, headers: typing.Mapping[str, str] | None = None, retries: Retry | None = None, timeout: _TYPE_TIMEOUT = _DEFAULT_TIMEOUT, chunked: bool = False, response_conn: BaseHTTPConnection | None = None, preload_content: bool = True, decode_content: bool = True, enforce_content_length: bool = True, ) -> BaseHTTPResponse: """ Perform a request on a given urllib connection object taken from our pool. :param conn: a connection from one of our connection pools :param method: HTTP request method (such as GET, POST, PUT, etc.) :param url: The URL to perform the request on. :param body: Data to send in the request body, either :class:`str`, :class:`bytes`, an iterable of :class:`str`/:class:`bytes`, or a file-like object. :param headers: Dictionary of custom headers to send, such as User-Agent, If-None-Match, etc. If None, pool headers are used. If provided, these headers completely replace any pool-specific headers. :param retries: Configure the number of retries to allow before raising a :class:`~urllib3.exceptions.MaxRetryError` exception. Pass ``None`` to retry until you receive a response. Pass a :class:`~urllib3.util.retry.Retry` object for fine-grained control over different types of retries. Pass an integer number to retry connection errors that many times, but no other types of errors. Pass zero to never retry. If ``False``, then retries are disabled and any exception is raised immediately. Also, instead of raising a MaxRetryError on redirects, the redirect response will be returned. :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. :param timeout: If specified, overrides the default timeout for this one request. It may be a float (in seconds) or an instance of :class:`urllib3.util.Timeout`. :param chunked: If True, urllib3 will send the body using chunked transfer encoding. Otherwise, urllib3 will send the body using the standard content-length form. Defaults to False. :param response_conn: Set this to ``None`` if you will handle releasing the connection or set the connection to have the response release it. :param preload_content: If True, the response's body will be preloaded during construction. :param decode_content: If True, will attempt to decode the body based on the 'content-encoding' header. :param enforce_content_length: Enforce content length checking. Body returned by server must match value of Content-Length header, if present. Otherwise, raise error. """ self.num_requests += 1 timeout_obj = self._get_timeout(timeout) timeout_obj.start_connect() conn.timeout = Timeout.resolve_default_timeout(timeout_obj.connect_timeout) try: # Trigger any extra validation we need to do. try: self._validate_conn(conn) except (SocketTimeout, BaseSSLError) as e: self._raise_timeout(err=e, url=url, timeout_value=conn.timeout) raise # _validate_conn() starts the connection to an HTTPS proxy # so we need to wrap errors with 'ProxyError' here too. except ( OSError, NewConnectionError, TimeoutError, BaseSSLError, CertificateError, SSLError, ) as e: new_e: Exception = e if isinstance(e, (BaseSSLError, CertificateError)): new_e = SSLError(e) # If the connection didn't successfully connect to it's proxy # then there if isinstance( new_e, (OSError, NewConnectionError, TimeoutError, SSLError) ) and (conn and conn.proxy and not conn.has_connected_to_proxy): new_e = _wrap_proxy_error(new_e, conn.proxy.scheme) raise new_e # conn.request() calls http.client.*.request, not the method in # urllib3.request. It also calls makefile (recv) on the socket. try: conn.request( method, url, body=body, headers=headers, chunked=chunked, preload_content=preload_content, decode_content=decode_content, enforce_content_length=enforce_content_length, ) # We are swallowing BrokenPipeError (errno.EPIPE) since the server is # legitimately able to close the connection after sending a valid response. # With this behaviour, the received response is still readable. except BrokenPipeError: pass except OSError as e: # MacOS/Linux # EPROTOTYPE and ECONNRESET are needed on macOS # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/ # Condition changed later to emit ECONNRESET instead of only EPROTOTYPE. if e.errno != errno.EPROTOTYPE and e.errno != errno.ECONNRESET: raise # Reset the timeout for the recv() on the socket read_timeout = timeout_obj.read_timeout if not conn.is_closed: # In Python 3 socket.py will catch EAGAIN and return None when you # try and read into the file pointer created by http.client, which # instead raises a BadStatusLine exception. Instead of catching # the exception and assuming all BadStatusLine exceptions are read # timeouts, check for a zero timeout before making the request. if read_timeout == 0: raise ReadTimeoutError( self, url, f"Read timed out. (read timeout={read_timeout})" ) conn.timeout = read_timeout # Receive the response from the server try: > response = conn.getresponse() ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connectionpool.py:534: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connection.py:516: in getresponse httplib_response = super().getresponse() /opt/pyenv/versions/3.11.10/lib/python3.11/http/client.py:1395: in getresponse response.begin() /opt/pyenv/versions/3.11.10/lib/python3.11/http/client.py:325: in begin version, status, reason = self._read_status() /opt/pyenv/versions/3.11.10/lib/python3.11/http/client.py:286: in _read_status line = str(self.fp.readline(_MAXLINE + 1), "iso-8859-1") _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ self = b = def readinto(self, b): """Read up to len(b) bytes into the writable buffer *b* and return the number of bytes read. If the socket is non-blocking and no bytes are available, None is returned. If *b* is non-empty, a 0 return value indicates that the connection was shutdown at the other end. """ self._checkClosed() self._checkReadable() if self._timeout_occurred: raise OSError("cannot read from timed out object") while True: try: > return self._sock.recv_into(b) E TimeoutError: timed out /opt/pyenv/versions/3.11.10/lib/python3.11/socket.py:718: TimeoutError The above exception was the direct cause of the following exception: self = request = , stream = False timeout = Timeout(connect=10, read=10, total=None), verify = True, cert = None proxies = OrderedDict() def send( self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None ): """Sends PreparedRequest object. Returns Response object. :param request: The :class:`PreparedRequest ` being sent. :param stream: (optional) Whether to stream the request content. :param timeout: (optional) How long to wait for the server to send data before giving up, as a float, or a :ref:`(connect timeout, read timeout) ` tuple. :type timeout: float or tuple or urllib3 Timeout object :param verify: (optional) Either a boolean, in which case it controls whether we verify the server's TLS certificate, or a string, in which case it must be a path to a CA bundle to use :param cert: (optional) Any user-provided SSL certificate to be trusted. :param proxies: (optional) The proxies dictionary to apply to the request. :rtype: requests.Response """ try: conn = self.get_connection_with_tls_context( request, verify, proxies=proxies, cert=cert ) except LocationValueError as e: raise InvalidURL(e, request=request) self.cert_verify(conn, request.url, verify, cert) url = self.request_url(request, proxies) self.add_headers( request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies, ) chunked = not (request.body is None or "Content-Length" in request.headers) if isinstance(timeout, tuple): try: connect, read = timeout timeout = TimeoutSauce(connect=connect, read=read) except ValueError: raise ValueError( f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, " f"or a single float to set both timeouts to the same value." ) elif isinstance(timeout, TimeoutSauce): pass else: timeout = TimeoutSauce(connect=timeout, read=timeout) try: > resp = conn.urlopen( method=request.method, url=url, body=request.body, headers=request.headers, redirect=False, assert_same_host=False, preload_content=False, decode_content=False, retries=self.max_retries, timeout=timeout, chunked=chunked, ) ../.tox/testsPCE/lib/python3.11/site-packages/requests/adapters.py:667: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connectionpool.py:841: in urlopen retries = retries.increment( ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/util/retry.py:474: in increment raise reraise(type(error), error, _stacktrace) ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/util/util.py:39: in reraise raise value ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connectionpool.py:787: in urlopen response = self._make_request( ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connectionpool.py:536: in _make_request self._raise_timeout(err=e, url=url, timeout_value=read_timeout) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ self = err = TimeoutError('timed out') url = '/rests/operations/transportpce-pce:path-computation-request' timeout_value = 10 def _raise_timeout( self, err: BaseSSLError | OSError | SocketTimeout, url: str, timeout_value: _TYPE_TIMEOUT | None, ) -> None: """Is the error actually a timeout? Will raise a ReadTimeout or pass""" if isinstance(err, SocketTimeout): > raise ReadTimeoutError( self, url, f"Read timed out. (read timeout={timeout_value})" ) from err E urllib3.exceptions.ReadTimeoutError: HTTPConnectionPool(host='localhost', port=8181): Read timed out. (read timeout=10) ../.tox/testsPCE/lib/python3.11/site-packages/urllib3/connectionpool.py:367: ReadTimeoutError During handling of the above exception, another exception occurred: self = def test_11_path_computation_rdm_uni(self): self.path_computation_input_data["service-a-end"]["node-id"] = "OpenROADM-2-1" self.path_computation_input_data["service-a-end"]["clli"] = "cll21" self.path_computation_input_data["service-z-end"]["node-id"] = "OpenROADM-2-2" self.path_computation_input_data["service-z-end"]["clli"] = "ncli22" > response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) transportpce_tests/pce/test01_pce.py:199: _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ transportpce_tests/common/test_utils.py:706: in transportpce_api_rpc_request response = post_request(url, data) transportpce_tests/common/test_utils.py:142: in post_request return requests.request( ../.tox/testsPCE/lib/python3.11/site-packages/requests/api.py:59: in request return session.request(method=method, url=url, **kwargs) ../.tox/testsPCE/lib/python3.11/site-packages/requests/sessions.py:589: in request resp = self.send(prep, **send_kwargs) ../.tox/testsPCE/lib/python3.11/site-packages/requests/sessions.py:703: in send r = adapter.send(request, **kwargs) _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ self = request = , stream = False timeout = Timeout(connect=10, read=10, total=None), verify = True, cert = None proxies = OrderedDict() def send( self, request, stream=False, timeout=None, verify=True, cert=None, proxies=None ): """Sends PreparedRequest object. Returns Response object. :param request: The :class:`PreparedRequest ` being sent. :param stream: (optional) Whether to stream the request content. :param timeout: (optional) How long to wait for the server to send data before giving up, as a float, or a :ref:`(connect timeout, read timeout) ` tuple. :type timeout: float or tuple or urllib3 Timeout object :param verify: (optional) Either a boolean, in which case it controls whether we verify the server's TLS certificate, or a string, in which case it must be a path to a CA bundle to use :param cert: (optional) Any user-provided SSL certificate to be trusted. :param proxies: (optional) The proxies dictionary to apply to the request. :rtype: requests.Response """ try: conn = self.get_connection_with_tls_context( request, verify, proxies=proxies, cert=cert ) except LocationValueError as e: raise InvalidURL(e, request=request) self.cert_verify(conn, request.url, verify, cert) url = self.request_url(request, proxies) self.add_headers( request, stream=stream, timeout=timeout, verify=verify, cert=cert, proxies=proxies, ) chunked = not (request.body is None or "Content-Length" in request.headers) if isinstance(timeout, tuple): try: connect, read = timeout timeout = TimeoutSauce(connect=connect, read=read) except ValueError: raise ValueError( f"Invalid timeout {timeout}. Pass a (connect, read) timeout tuple, " f"or a single float to set both timeouts to the same value." ) elif isinstance(timeout, TimeoutSauce): pass else: timeout = TimeoutSauce(connect=timeout, read=timeout) try: resp = conn.urlopen( method=request.method, url=url, body=request.body, headers=request.headers, redirect=False, assert_same_host=False, preload_content=False, decode_content=False, retries=self.max_retries, timeout=timeout, chunked=chunked, ) except (ProtocolError, OSError) as err: raise ConnectionError(err, request=request) except MaxRetryError as e: if isinstance(e.reason, ConnectTimeoutError): # TODO: Remove this in 3.0.0: see #2811 if not isinstance(e.reason, NewConnectionError): raise ConnectTimeout(e, request=request) if isinstance(e.reason, ResponseError): raise RetryError(e, request=request) if isinstance(e.reason, _ProxyError): raise ProxyError(e, request=request) if isinstance(e.reason, _SSLError): # This branch is for urllib3 v1.22 and later. raise SSLError(e, request=request) raise ConnectionError(e, request=request) except ClosedPoolError as e: raise ConnectionError(e, request=request) except _ProxyError as e: raise ProxyError(e) except (_SSLError, _HTTPError) as e: if isinstance(e, _SSLError): # This branch is for urllib3 versions earlier than v1.22 raise SSLError(e, request=request) elif isinstance(e, ReadTimeoutError): > raise ReadTimeout(e, request=request) E requests.exceptions.ReadTimeout: HTTPConnectionPool(host='localhost', port=8181): Read timed out. (read timeout=10) ../.tox/testsPCE/lib/python3.11/site-packages/requests/adapters.py:713: ReadTimeout ____________ TransportPCEtesting.test_15_success1_path_computation _____________ self = def test_15_success1_path_computation(self): self.path_computation_input_data["service-name"] = "service 1" self.path_computation_input_data["service-a-end"] = {"service-format": "Ethernet", "service-rate": "100", "clli": "ORANGE2", "node-id": "XPONDER-2-2"} self.path_computation_input_data["service-z-end"] = {"service-format": "Ethernet", "service-rate": "100", "clli": "ORANGE1", "node-id": "XPONDER-1-2"} self.path_computation_input_data["hard-constraints"] = {"customer-code": ["Some customer-code"], "co-routing": { "service-identifier-list": [{ "service-identifier": "Some existing-service"}] }} self.path_computation_input_data["soft-constraints"] = {"customer-code": ["Some customer-code"], "co-routing": { "service-identifier-list": [{ "service-identifier": "Some existing-service"}] }} response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 500 != 200 transportpce_tests/pce/test01_pce.py:265: AssertionError ____________ TransportPCEtesting.test_16_success2_path_computation _____________ self = def test_16_success2_path_computation(self): self.path_computation_input_data["service-a-end"]["node-id"] = "XPONDER-1-2" self.path_computation_input_data["service-a-end"]["clli"] = "ORANGE1" self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-3-2" self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE3" del self.path_computation_input_data["hard-constraints"] del self.path_computation_input_data["soft-constraints"] response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 500 != 200 transportpce_tests/pce/test01_pce.py:282: AssertionError ____________ TransportPCEtesting.test_17_success3_path_computation _____________ self = def test_17_success3_path_computation(self): self.path_computation_input_data["hard-constraints"] = {"exclude": {"node-id": ["OpenROADM-2-1", "OpenROADM-2-2"]}} response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 500 != 200 transportpce_tests/pce/test01_pce.py:298: AssertionError __ TransportPCEtesting.test_18_path_computation_before_oms_attribute_deletion __ self = def test_18_path_computation_before_oms_attribute_deletion(self): self.path_computation_input_data["service-a-end"]["node-id"] = "XPONDER-2-2" self.path_computation_input_data["service-a-end"]["clli"] = "ORANGE2" self.path_computation_input_data["service-z-end"]["node-id"] = "XPONDER-1-2" self.path_computation_input_data["service-z-end"]["clli"] = "ORANGE1" del self.path_computation_input_data["hard-constraints"] response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 500 != 200 transportpce_tests/pce/test01_pce.py:317: AssertionError __ TransportPCEtesting.test_20_path_computation_after_oms_attribute_deletion ___ self = def test_20_path_computation_after_oms_attribute_deletion(self): response = test_utils.transportpce_api_rpc_request('transportpce-pce', 'path-computation-request', self.path_computation_input_data) > self.assertEqual(response['status_code'], requests.codes.ok) E AssertionError: 500 != 200 transportpce_tests/pce/test01_pce.py:344: AssertionError --------------------------- Captured stdout teardown --------------------------- all processes killed =========================== short test summary info ============================ FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_01_load_port_mapping FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_02_load_simple_topology_bi FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_03_get_nodeId FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_04_get_linkId FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_05_path_computation_xpdr_bi FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_06_path_computation_rdm_bi FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_07_load_simple_topology_uni FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_08_get_nodeId FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_09_get_linkId FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_10_path_computation_xpdr_uni FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_11_path_computation_rdm_uni FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_15_success1_path_computation FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_16_success2_path_computation FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_17_success3_path_computation FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_18_path_computation_before_oms_attribute_deletion FAILED transportpce_tests/pce/test01_pce.py::TransportPCEtesting::test_20_path_computation_after_oms_attribute_deletion 16 failed, 4 passed in 108.79s (0:01:48)